vk: VRAM, system RAM, GPU and replay CPU time: streams and staging out of VRAM, memory given back when idle, redundant barriers left out, draw setup cached - #585

…ts of their own (RX_VK_BLOCK_BUFFERS=1: shares of 64 MB blocks)

A 24 MB buffer is under half of VMA's 64 MB block (over it VMA goes dedicated by itself), so two fit in a block and 16 MB of it stays
free: with the streams in VRAM (previous commit) 24 blocks of 1536 MB held 1152 MB, and the page table (24 MB) sat in a block of
its own with 40 MB free. Those free bytes are what the log's "N MB of it free in the blocks" counts, and the driver counts them
as the process's. create_buffer takes a `dedicated` flag now; the streams and the page table pass it. Their count of memory objects
(~25) is nothing against the 4096 the driver allows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

… line), RX_VK_STREAM_MB=<n> sets its size (24)

The 24 MB per recording was never full in any log (no "stream is full" line), but nothing says how much a recording uses: the banks
c0/c2 (at most 2560 B a stage a draw, repeated ones shared), the c1s, the uniform overlays (57 of up to 64 KB a frame) and the
quad indices. Logged every 3000 recordings (~10 s): the streams made, their size, the most one held. With a peak of a few MB,
RX_VK_STREAM_MB=8 (or 4) takes another 380 MB (or 480) of VRAM off the 24 streams; a recording that overflows skips its quads and
reads null uniforms, so size it by that peak with room.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

… are given back (RX_VK_STAGING_KEEP_MB=256: as before)

The staging arenas are create_buffer(TRANSFER_SRC | STORAGE, host visible): STORAGE is device access, so VMA prefers
DEVICE_LOCAL | HOST_VISIBLE for them, and on a card with resizable BAR that is VRAM (the RTX 4050 Laptop's memory type 4, in the 6 GB
heap). The low-vram log: arenas 3 and 4 (288 and 64 MB: a 12288 x 12288 texture's upload at the scene load) were made between
presents 2280 and 2400, and "staging 256 MB in 4 arenas" stands at every 600-frame look after that, with no arena made again:
~nothing is staged in Kokiri gameplay. 192 MB of the 5.7 GB VRAM the texture budget fights for, idle. A scene change that stages
again makes its arenas again (a 64 MB host-visible allocation each); the ones over 64 MB were already given back when idle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

…h, staging, glibc heap)

- A recording's stream is 2 MB, and a recording that outgrows it moves to a bigger one instead of skipping draws; extra streams are given back after 120 recordings that fit the first (RX_VK_STREAM_GROW_OFF=1: 24 MB and skips; RX_VK_STREAM_KEEP=1: kept).
- A capture's buffer by size class (2 MB up), not 16 MB each; dedicated memory from 16 MB; the spare buffers capped at 32 MB on a card of 6.5 GB or less (RX_VK_CAP_MIN_MB=16, RX_VK_CAP_BLOCKS=1, RX_VK_CAP_SPARE_MB=0: as before).
- The BC3 scratch (160 MB) is made at the first upload that needs it, in memory of its own, and given back after 20 s without one (RX_VK_BC_IDLE_S=0: kept; RX_VK_BC_POOL=1: from the pool).
- The texture budget counts the allocator's size of an image, not its texels (RX_VK_COUNT_BY_ESTIMATE=1: the texels).
- The TAAU stand-in's replaced history image is destroyed 120 presents later (RX_VK_TAAU_HIST_LEAK=1: left).
- flush_texture reads back into cached host memory (RX_VK_FLUSH_UNCACHED=1: the sequential-write buffer).
- Shadow copies of texture pages no capture took in 256 submits are dropped once there are 32 MB of them (RX_VK_SHADOW_SWEEP_OFF=1: only at the 256 MB cap).
- A staging arena nothing has staged into for 30 s is given back, the last one too (RX_VK_STAGING_IDLE_S=0: as before).
- Linux (glibc): malloc_trim(0) on a worker when the arenas hold 192 MB or more free, and a "vk: malloc:" census line, every 1800 presents (RX_VK_MALLOC_TRIM_MB=0: never).
- Knobs, defaults unchanged: RX_VK_DESC_POOL_DIV=<n>, RX_VK_IMAGE_BLOCK_MB=<n>; HOS_NO_THP=1 (Linux: transparent huge pages off for the process).
- tests/test_mem_trim.py: the stream move, the BC3 scratch's users and the capture buffers' counts keep their invariants.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

…is left out; RX_VK_PASS_TIMING GPU profile

- vk_work.h counts the GPU work recorded on a command buffer (an atomic add; every work-doing vkCmd goes through its macros). A full barrier right after another one on the same command buffer, nothing recorded between, is left out; the last-barrier state is per thread, and transfer_barrier goes through the same check. Off during parallel replay. RX_VK_BARRIER_DEDUPE_OFF=1: all recorded. The frame log tells the barriers recorded and left out.
- RX_VK_PASS_TIMING=1|2 (alias RX_VK_GPU_PROFILE): GPU timestamps around passes, dispatches, barriers (by origin), copies, mirror syncs and write-backs, both kinds of command buffer summed, reported every 600 presents with the costliest spans; =2 adds one per program run inside passes.
- The frame log counts the game's nvnCommandBufferBarrier calls by their NVN bits, and the 'bound in guest memory, by pool' line adds the bytes of the bindings (what the GPU may read over PCIe).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

… and mip levels get at least n-times anisotropy (default 0: the game's own); the log tells each anisotropy the game asks for

The sampler's key and its per-slot cache's key carry n, so a cached sampler is never one made for another value. A sampler with a
nearest min filter or mip filter keeps the game's value (a depth-compare sampler too unless it filters that way). n is clamped to the
device's limit (and to 16) and needs samplerAnisotropy. "vk: sampler anisotropy: the game asks for ..." is logged once for each value
(16 at most), to learn what the game sets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

…e by what the program masks, banks by their bindings' generation, program picks across uniform rebinds

A draw's CPU cost on the replay thread, from four places where most of the work found what the draw before it had found. Same
descriptors, state, banks and programs as before; only what is kept, and what it is kept by, changes.

- Pushed descriptors, one vector of words (RX_VK_PUSH_STATE_OLD=1: the vector of vectors). A program change pushes every write and
  remembers them for the draws after it, which push only the writes that changed. The memory was a vector of vectors resized to each
  program's writes (3 allocations a write grown word by word, the ones cut off freed, a dozen of each a draw), and the changed-only
  path built every write's words into a scratch vector to compare them. Now the words of all writes are in one vector with each
  write's start, built without allocating once grown; a later draw compares each write against its words in place and stores the new
  ones where they differ. Default on: same pushes, same words. tests/test_push_state.py.
- Dynamic state by what the program masks (RX_VK_DYN_PROG_KEY=1: by the program). dynamic_state returns early when the packed inputs
  equal the draw before's, but the pack held the program's pointer (its write masks come from the fragment stage), so every program
  change, most draws, worked the whole state out again. It holds program_wm_sig now: the fragment stage's stored outputs and their
  components, all target_write_mask reads of the program (tests/test_same_dyn.py keeps the two in step). Default on. Program::wm_sig
  is atomic: replay threads may ask for the same program at once.
- Driver banks by the generation of the bindings they are made from (RX_VK_BANK_GEN_OFF=1: by bind_gen). uniform_range kept a stage's
  c0 / c2 bank only while bind_gen stood, and OoT binds a uniform buffer for nearly every draw, so each draw filled the banks of all
  its stages again to find, mostly, the same words. A graphics stage's c2 is made from its texture, sampler and image handles and its
  c0 from its storage buffer table, so NvnState keeps what bind_gen was when each last changed (tex_gen, ssbo_gen per stage) and the
  bank stands while that does. Compute, task and mesh stages stay on bind_gen. A state's generations are made afresh with its
  bind_gen when the replay takes another queue's state. Default on. tests/test_bank_gen.py.
- Program picks across uniform rebinds (RX_VK_PICK_BIND_GEN=1: as before). The pair of last picks in program_for stood only while
  bind_gen did. A graphics program whose every answer is a plain c2 handle (answer_stage_mask: no handle program, no other bank)
  now stands while those stages' tex_gen do; handle programs, compute and task / mesh programs keep bind_gen. The "program picks"
  log line counts the picks taken this way. Default on; builds on the banks' tex_gen. tests/test_pick_tex_gen.py.
- RX_VK_PROF_FINE=1 (diagnostic, off by default; off, each site is a test of one constant): a frame line "a frame (fine)" with the
  descriptor build split into the driver banks, c1, user uniform buffers, storage buffers and textures, and the commands split into
  hazards and the pass, the pipeline bind, the descriptor bind and its push call, the push constants, dynamic state, the vertex and
  index binds and the draw call, in ms a frame; and a second line with what a draw does (descriptors and writes built, bank fills and
  bytes, stream copies, full and changed-only pushes, pipeline binds, dynamic state from the draw before or worked out and its
  commands, vertex and index binds, pipeline keys from the fast pair or the thread's map).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>